home *** CD-ROM | disk | FTP | other *** search
/ Workbench Design / WB Collection.iso / workbench werkzeuge / bildschirmschoner / snowblank / source / snow / blank.c next >
C/C++ Source or Header  |  1996-04-07  |  6KB  |  265 lines
  1. /* --------------------------------------------------------------------
  2.  *
  3.  *             A christmas blanker inspired by xsnow
  4.  *
  5.  *    initialization/cleanup code copied from the dragon module
  6.  *      (dragon module: (C)Alexander Kneer and Michael D. Bayne)
  7.  * 
  8.  * -------------------------------------------------------------------- */
  9.  
  10.  
  11. #include <exec/memory.h>
  12. #include <math.h>
  13. #include <stdlib.h>
  14.  
  15. #include "/includes.h"
  16.  
  17. #define STAGES 2        /* Number of different shapes */
  18. #define BLANKDELAY 100        /* This many snowflakes are displayed before
  19.                  * we check if to continue blanking */
  20. #define COUNTLIMIT 6        /* max. number of moves in one direction */
  21. #define COUNTMIN 1        /* min. number of moves in one direction */
  22.  
  23. /* random generation function macros */
  24. #define COUNTFUNC RangeRand(COUNTLIMIT-COUNTMIN)+COUNTMIN
  25. #define DXFUNC    RangeRand(5)-2;
  26. #define DYFUNC    RangeRand(2)+1;
  27.  
  28. typedef enum { false, true } bool;
  29.  
  30. bool BIGFLAKES;
  31. int  NUMSNOW;
  32. bool COLLECT;
  33.  
  34. int patx[10] = {  -1,-1, 1, 1, 0  , -1, 1, 0, 0, 0 };
  35. int paty[10] = {  -1, 1,-1, 1, 0  ,  0, 0, 1,-1, 0 };
  36.  
  37. int *collect;
  38.  
  39. typedef struct 
  40.   { int x,y;            /* The current coordinates */
  41.     int dx,dy;            /* Movement direction is (dx,dy) */
  42.     int count;            /* How long to keep direction dx */
  43.     int stage;            /* STAGES different shapes */
  44.   } snowflake;
  45.  
  46.  
  47. Triplet *ColorTable = 0L;
  48.  
  49.  
  50. #define PR_FLAKE   0
  51. #define PR_BIG     2
  52. #define PR_COLLECT 4
  53. #define PR_MODE    6
  54.  
  55. VOID Defaults( PrefObject *Prefs )
  56. {
  57.   Prefs[PR_FLAKE].po_Level = 200;
  58.   Prefs[PR_BIG].po_Level = 1;
  59.   Prefs[PR_COLLECT].po_Level = 1;
  60.   Prefs[PR_MODE].po_ModeID = getTopScreenMode();
  61. }
  62.  
  63.  
  64. /* Remove a single snowflake's image from the screen */
  65. __inline void undraw(snowflake *flake, struct RastPort *rp)
  66. { 
  67.   if (BIGFLAKES)
  68.     {
  69.       int *startx = patx + 5*(flake->stage);
  70.       int *starty = paty + 5*(flake->stage);
  71.       int i;
  72.       SetAPen(rp,0);
  73.       for (i=0; i<5; i++)
  74.     { WritePixel(rp,flake->x+(*startx),flake->y+(*starty));
  75.       startx++;
  76.       starty++;
  77.     }
  78.     }
  79.   else
  80.     {
  81.       SetAPen(rp,0);
  82.       WritePixel(rp,flake->x,flake->y);
  83.     }
  84. }
  85.  
  86.  
  87. /* Draw a single snowflake's image to the screen */
  88. __inline void draw(snowflake *flake, struct RastPort *rp)
  89. { 
  90.   if (BIGFLAKES)
  91.     {
  92.       int *startx = patx + 5*(flake->stage);
  93.       int *starty = paty + 5*(flake->stage);
  94.       int i;
  95.       SetAPen(rp,1);
  96.       for (i=0; i<5; i++)
  97.     { WritePixel(rp,flake->x+(*startx),flake->y+(*starty));
  98.       startx++;
  99.       starty++;
  100.     }
  101.     }
  102.   else
  103.     { SetAPen(rp,1);
  104.       WritePixel(rp,flake->x,flake->y);
  105.     }
  106. }
  107.  
  108.  
  109. /* change the position of a snowflake. If it leaves [0..width]x[0..height],
  110.  * generate a new one with coordinates (<random>,0) */
  111. __inline void update(snowflake *curr, int width, int height, struct RastPort *rp)
  112. { bool gen_new;
  113.   int oldx = curr->x;
  114.   if (curr->count > 0)
  115.     { curr->y = curr->y + curr->dy;
  116.       if (curr->y >= height-1)
  117.     { gen_new = true;
  118.     }
  119.       else
  120.     { curr->x = curr->x + curr->dx;
  121.       if (curr->x < 1 || curr->x >= width-1)
  122.         { gen_new = true;
  123.         }
  124.       else 
  125.         { gen_new = false;
  126.           (curr->count)--;
  127.           if (curr->count <= 0)
  128.         { curr->dx = DXFUNC;
  129.           curr->count = COUNTFUNC;
  130.         }
  131.           if (curr->stage)
  132.         { curr->stage--;
  133.         }
  134.           else
  135.         { curr->stage = STAGES-1;
  136.         }
  137.         }
  138.     }
  139.     }
  140.   
  141.   /* do we have to compute a new flake? */
  142.   if (gen_new)
  143.     { if (collect && curr->y > height-3)
  144.     { collect[oldx]--;
  145.       if (collect[oldx]<height-20)
  146.         { collect[oldx]=height-20;
  147.         }
  148.       
  149.       curr->x = oldx;
  150.       curr->y = collect[oldx];
  151.       draw(curr,rp);
  152.     }
  153.       curr->x = RangeRand(width-2)+1;
  154.       curr->y = 1;
  155.       curr->dx = DXFUNC;
  156.       curr->dy = DYFUNC;
  157.       curr->count = COUNTFUNC;
  158.       curr->stage = RangeRand(STAGES);
  159.     }
  160. }
  161.  
  162.  
  163.  
  164.  
  165. LONG snow(struct Screen *scr, SHORT width, SHORT height)
  166. {
  167.   unsigned int i;
  168.   LONG flg_end;
  169.   snowflake *flake,*curr;
  170.   int blankcount;
  171.   struct RastPort *rp = &(scr->RastPort);
  172.  
  173.   /* initialize the snow array */
  174.   flake = malloc(NUMSNOW*sizeof(snowflake));
  175.   curr = flake;
  176.   for (i=0; i<NUMSNOW; i++)
  177.     { curr->x = RangeRand(width-2)+1;
  178.       curr->y = RangeRand(height-2)+1;
  179.       curr->dx = DXFUNC;
  180.       curr->dy = DYFUNC;
  181.       curr->count = COUNTFUNC;
  182.       curr->stage = RangeRand(STAGES);
  183.       curr++;
  184.     }
  185.  
  186.   /* and the collect array */
  187.   if (COLLECT)
  188.     { collect = malloc(sizeof(int)*width);
  189.       for (i=0; i<width; i++)
  190.         { collect[i] = height-2;
  191.         }
  192.       collect[0] = 0;
  193.       collect[width-1] = 0;
  194.     }
  195.   else
  196.     { collect = NULL;
  197.     }
  198.  
  199.   /* Update all snowflakes forever. Update includes removal from the screen,
  200.    * computation of new position, drawing on the screen */
  201.   blankcount = BLANKDELAY;
  202.   while (1)
  203.     { curr = flake;
  204.       for (i=0; i<NUMSNOW; i++)
  205.     { /* Remove curr's image */
  206.       undraw(curr,rp);
  207.       /* compute new position and appearance */
  208.       update(curr,width,height,rp);
  209.       /* and display it */
  210.       draw(curr,rp);
  211.       /* can we continue? */
  212.       if (!blankcount)
  213.         { blankcount = BLANKDELAY;
  214.           flg_end = ContinueBlanking();
  215.           ScreenToFront(scr);
  216.           if (flg_end != OK)
  217.         { free(flake);
  218.           if (collect) free(collect);
  219.           return flg_end;
  220.         }
  221.         }
  222.       else
  223.         { blankcount--;
  224.         }
  225.       curr++;
  226.     }
  227.     }
  228.   return OK;            /* just for the compiler */
  229. }
  230.  
  231.  
  232. LONG Blank( PrefObject *Prefs )
  233. {
  234.     struct Screen *Scr;
  235.     struct Window *Wnd;
  236.     LONG RetVal;
  237.     
  238.         BIGFLAKES = Prefs[PR_BIG].po_Level;
  239.     NUMSNOW   = Prefs[PR_FLAKE].po_Level;
  240.     COLLECT   = Prefs[PR_COLLECT].po_Level;
  241.  
  242.     if( Scr = OpenScreenTags( NULL, SA_Depth, 1,
  243.                              SA_Quiet, TRUE, SA_DisplayID, Prefs[PR_MODE].po_ModeID,
  244.                              SA_Behind, TRUE, SA_Overscan, OSCAN_STANDARD,
  245.                              TAG_DONE ))
  246.     {
  247.         SetRGB4(&( Scr->ViewPort ), 0, 0, 0, 0 );
  248.         ColorTable = RainbowPalette( Scr, 0L, 1L, 0L );
  249.         SetRGB4(&( Scr->ViewPort ), 1, 15, 15, 15 );
  250.         Wnd = BlankMousePointer( Scr );
  251.         
  252.         do
  253.             RetVal = snow( Scr, Scr->Width, Scr->Height );
  254.         while( RetVal == OK );
  255.         
  256.         UnblankMousePointer( Wnd );
  257.         RainbowPalette( 0L, ColorTable, 1L, 0L );
  258.         CloseScreen( Scr );
  259.     }
  260.     else
  261.         RetVal = FAILED;
  262.     
  263.     return RetVal;
  264. }
  265.